import { apiRequest, get, post, put, del } from '../utils/api';
import {
  Article,
  ArticleListResponse,
  CreateArticleDto,
  UpdateArticleDto,
  ArticleQueryParams,
} from '../types/article';

// 获取文章列表（公共接口）
export const getArticles = async (
  params?: ArticleQueryParams
): Promise<ArticleListResponse> => {
  try {
    // 确保page和limit是数字类型
    const formattedParams = { ...params };
    if (params?.page !== undefined) {
      formattedParams.page = Number(params.page);
    }
    if (params?.limit !== undefined) {
      formattedParams.limit = Number(params.limit);
    }
    
    const response = await get<any>('/articles', formattedParams);
    
    // 直接在service层进行格式转换，确保返回正确的格式
    // console.log('从后端获取的原始响应:', response);
    if (response.articles && Array.isArray(response.articles)) {
      // console.log('检测到articles字段，进行格式转换');
      const formattedResponse: ArticleListResponse = {
        data: response.articles,
        total: response.total || response.articles.length,
        page: params?.page || 1,
        limit: params?.limit || 10,
        totalPages: Math.ceil((response.total || response.articles.length) / (params?.limit || 10))
      };
      // console.log('转换后的响应:', formattedResponse);
      return formattedResponse;
    }
    
    // 如果已经是正确的格式，直接返回
    if (response.data && Array.isArray(response.data)) {
      // console.log('已经是正确的格式，直接返回');
      return response as ArticleListResponse;
    }
    
    // 否则返回空数据
    // console.log('返回空数据结构');
    return {
      data: [],
      total: 0,
      page: params?.page || 1,
      limit: params?.limit || 10,
      totalPages: 0
    };
  } catch (error) {
    // console.error('获取文章列表失败:', error);
    // 出错时返回空数据，避免前端崩溃
    return {
      data: [],
      total: 0,
      page: params?.page || 1,
      limit: params?.limit || 10,
      totalPages: 0
    };
  }
};

// 获取文章详情（公共接口）
export const getArticleById = async (id: number, isMe?: boolean): Promise<Article> => {
  try {
    // 使用用户专用的接口路径，这样用户可以访问自己的所有文章（包括未审核的）
    let endpoint  = `/articles/${id}`;
    if (isMe) {
      endpoint = `/articles/user/${id}`;
    }
    
    const response = await get<any>(endpoint);
    
    // 处理不同的响应格式
    if (response && typeof response === 'object') {
      // 检查是否是直接返回的文章对象
      if (response.id && (response.title || response.content)) {
        return response as Article;
      }
      // 检查是否是包装在data字段中
      if (response.data) {
        return response.data as Article;
      }
    }
    
    throw new Error('获取文章详情失败：返回的数据格式不正确');
  } catch (error: any) {
    // 增强错误信息
    const errorMessage = error.response?.data?.message 
      || error.message 
      || '获取文章详情失败，请稍后重试';
    
    // 重新抛出带有更详细信息的错误
    const enhancedError = new Error(errorMessage);
    Object.assign(enhancedError, error);
    throw enhancedError;
  }
};

// 创建文章（用户接口）
export const createArticle = async (
  articleData: CreateArticleDto
): Promise<Article> => {
  try {
    // 确保传递给后端的数据结构正确
    const formattedData = {
      ...articleData,
      // 确保tagIds是数组，避免潜在问题
      tagIds: Array.isArray(articleData.tagIds) ? articleData.tagIds : []
    };
    
    const response = await post<any>('/articles/user', formattedData);
    
    // 处理可能的不同响应格式
    if (response && typeof response === 'object') {
      // 检查是否是直接返回的文章对象
      if (response.id && (response.title || response.content)) {
        return response as Article;
      }
      // 检查是否是包装在data字段中
      if (response.data) {
        return response.data as Article;
      }
    }
    
    // 如果响应格式不符合预期，抛出错误
    throw new Error('创建文章成功，但返回的数据格式不正确');
  } catch (error: any) {
    // 增强错误信息
    const errorMessage = error.response?.data?.message 
      || error.message 
      || '文章创建失败，请检查输入并重试';
    
    // 重新抛出带有更详细信息的错误
    const enhancedError = new Error(errorMessage);
    // 保留原始错误的属性，便于上层处理
    Object.assign(enhancedError, error);
    throw enhancedError;
  }
};

// 更新文章（用户接口）
export const updateArticle = async (
  id: number,
  articleData: UpdateArticleDto
): Promise<Article> => {
  return put<Article>(`/articles/user/${id}`, articleData);
};


// 删除文章（用户接口）
export const deleteArticle = async (id: number): Promise<void> => {
  return del<void>(`/articles/user/${id}`);
};



// 获取当前用户的文章列表（用户接口）
export const getUserArticles = async (): Promise<Article[]> => {
  try {
      const response = await get<any>('/articles/user/my');
    // 处理不同的响应格式
    if (response && Array.isArray(response)) {
      return response as Article[];
    }
    if (response && response.data && Array.isArray(response.data)) {
      return response.data as Article[];
    }
    return [];
  } catch (error) {
    console.error('获取用户文章失败:', error);
    return [];
  }
};

// // 更新文章状态（用户接口）
// export const updateArticleStatus = async (id: number, status: { isActive: number }): Promise<Article> => {
//   return put<Article>(`/articles/user/${id}/status`, status);
// };


// 获取热门文章（公共接口）
export const getPopularArticles = async (limit: number = 10): Promise<Article[]> => {
  return get<Article[]>('/articles/popular', { limit });
};
